package com.aaa.vegetablemarketexpress.service.impl;

import com.aaa.vegetablemarketexpress.entity.*;
import com.aaa.vegetablemarketexpress.dao.OrderDao;
import com.aaa.vegetablemarketexpress.dao.OrderItemDao;
import com.aaa.vegetablemarketexpress.dao.OrderActDao;
import com.aaa.vegetablemarketexpress.service.OrderService;
import com.aaa.vegetablemarketexpress.util.ConstantUtil;
import com.aaa.vegetablemarketexpress.util.HttpClient;
import com.github.wxpay.sdk.WXPayUtil;
import lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import java.math.BigDecimal;
import java.util.*;

/**
 * @FileName: OrderServiceImpl
 * @Description: 订单服务实现类
 * @Author:
 * @CreateTime: 2025/9/10
 * @Version: 1.0.0
 */
@Service
@Log4j2
public class OrderServiceImpl implements OrderService {

    @Resource
    private OrderDao orderDao;

    @Resource
    private OrderItemDao orderItemDao;

    @Resource
    private OrderActDao orderActDao;

    /**
     * 创建订单
     * @param order 订单信息
     * @param session HTTP会话
     */
    @Override
    @Transactional
    public void createOrder(Order order, HttpSession session) {
        // 从session中获取当前登录用户信息
        User currentUser = (User) session.getAttribute("userInfo");

        // 设置订单必要字段
        order.setOrderDate(new Date());
        order.setCreateTime(new Date());
        order.setDelFlag("0"); // 0表示未删除

        // 设置用户ID
        if (currentUser != null) {
            if (order.getUserId() == null) {
                order.setUserId(currentUser.getUserId());
            }
            if (order.getCreateBy() == null) {
                order.setCreateBy(currentUser.getUserName());
            }
        }

        // 设置默认备注
        if (order.getRemark() == null) {
            order.setRemark("鲜时蔬购物订单");
        }

        // 插入订单主表
        orderDao.insertOrder(order);

        // 保存订单明细
        if (order.getOrderItems() != null && !order.getOrderItems().isEmpty()) {
            for (OrderItem item : order.getOrderItems()) {
                item.setOrderId(order.getOrderId());
                item.setCreateTime(new Date());
                // 确保必要字段都有值
                if (item.getOrderQuantity() == null) {
                    item.setOrderQuantity(new BigDecimal("1"));
                }
                if (item.getSalePrice() == null) {
                    item.setSalePrice(new BigDecimal("0"));
                }
                if (item.getAmount() == null) {
                    item.setAmount(item.getOrderQuantity().multiply(item.getSalePrice()));
                }
                orderItemDao.insertOrderItem(item);
            }
        }

        // 创建订单操作记录（待支付状态）
        OrderAct orderAct = new OrderAct();
        orderAct.setOrderactid(UUID.randomUUID().toString().replace("-", ""));
        orderAct.setOrderNo(order.getOrderNo());
        orderAct.setActno(0); // 0-待支付
        orderAct.setCztime(new Date());
        if (currentUser != null) {
            orderAct.setCzrid(currentUser.getUserId().toString());
        } else {
            orderAct.setCzrid("system");
        }
        orderAct.setRemark("订单创建，待支付");
        orderActDao.insertOrderAct(orderAct);
    }



    /**
     * 更新订单状态
     * @param order 订单信息
     */
    @Override
    @Transactional
    public void updateOrderStatus(Order order) {
        // 1. 更新订单主表最后修改时间
        orderDao.updateOrderStatus(order);

        // 2. 创建订单操作记录（已支付状态）
        OrderAct orderAct = new OrderAct();
        orderAct.setOrderactid(UUID.randomUUID().toString().replace("-", ""));
        orderAct.setOrderNo(order.getOrderNo());
        orderAct.setActno(1); // 1-已支付
        orderAct.setCztime(new Date());
        orderAct.setCzrid(order.getUserId() != null ? order.getUserId().toString() : "system");
        orderAct.setRemark("订单支付成功");
        orderActDao.insertOrderAct(orderAct); // 这里才是真正的状态变更操作
    }


    /**
     * @Description: 获取微信支付状态
     * @Param: [orderid]
     * @return: java.util.Map
     * @Author:
     * @CreateTime:
     */
    @Override
    public Map getPayStatus(String orderNo) {
        try {
            Map paramMap = new HashMap();
            //参数
            paramMap.put("appid", ConstantUtil.PayConfig.APPID);
            paramMap.put("mch_id", ConstantUtil.PayConfig.MCH_ID);
            paramMap.put("out_trade_no", orderNo+"");
            paramMap.put("nonce_str", WXPayUtil.generateNonceStr());

            HttpClient client = new HttpClient("https://api.mch.weixin.qq.com/pay/orderquery");
            client.setXmlParam(WXPayUtil.generateSignedXml(paramMap, ConstantUtil.PayConfig.API_KEY));
            client.setHttps(true);
            client.post();
            String xml = client.getContent();//xml
            System.out.println("支付后的信息========" + xml);
            Map<String, String> resultMap = WXPayUtil.xmlToMap(xml);
            System.out.println("支付之后的信息的内容==================="+resultMap);
            return resultMap;
        }catch(Exception e){
            e.printStackTrace();
        }
        return null;
    }
    /**
     * @Description: 获取微信支付二维码
     * @Param: [order]
     * @return: java.util.Map
     * @Author:
     * @CreateTime:
     */
    @Override
    public Map getNativeByOrder(Order order) {
        try {
            //统一下单   生成预支付的订单
            Map paramMap = new HashMap();
            //参数
            paramMap.put("appid", ConstantUtil.PayConfig.APPID);
            paramMap.put("mch_id", ConstantUtil.PayConfig.MCH_ID);
            // 修复：使用订单编号orderNo替代orderId，避免null异常
            paramMap.put("out_trade_no", order.getOrderNo());
            //paramMap.put("total_fee", order.getTotalAmount().multiply(new BigDecimal("100")).longValue() + ""); //单位 分
            // 修改：将支付金额固定为0.01元(1分钱)用于测试
            paramMap.put("total_fee", "1"); //单位为分，1分钱
            paramMap.put("body", order.getRemark());
            paramMap.put("nonce_str", WXPayUtil.generateNonceStr());
            paramMap.put("spbill_create_ip", "127.0.0.1");
            paramMap.put("trade_type", "NATIVE");
            paramMap.put("notify_url", "http://www.chenkaixiang.top/notifyWeiXinPay");

            //统一下单
            HttpClient client = new HttpClient("https://api.mch.weixin.qq.com/pay/unifiedorder");
            client.setXmlParam(WXPayUtil.generateSignedXml(paramMap, ConstantUtil.PayConfig.API_KEY));
            client.setHttps(true);
            client.post();

            //生成的预支付订单的消息
            String xml=client.getContent();//xml
            System.out.println("-------------"+xml);
            Map<String, String> resultMap = WXPayUtil.xmlToMap(xml);
            Order order1 = orderDao.selectOrderByOrderNo(order.getOrderNo());//获取订单
            order1.setCodeUrl(resultMap.get("code_url"));//添加二维码
            orderDao.updateOrder(order1);//更新订单状态
            System.out.println(resultMap);
            Map returnMap = new HashMap<>();
            returnMap.put("code_url", resultMap.get("code_url"));

            return returnMap;
        }catch(Exception e){
            log.error(e.getMessage());
        }
        return null;
    }
//    /**
//     * 获取商家订单列表
//     * @param request 查询参数
//     * @param session 用户会话
//     * @return 订单列表
//     */
//    @Override
//    public Map<String, Object> getShopOrders(Map<String, Object> request, HttpSession session) {
//        User currentUser = (User) session.getAttribute("userInfo");
//        if (currentUser == null) {
//            throw new RuntimeException("用户未登录");
//        }
//
//        // 查询客户（商家）信息
//        Customer customer = orderDao.selectCustomerByUserId(currentUser.getUserId());
//        if (customer == null) {
//            log.warn("用户ID为 {} 的用户未找到对应的客户（商家）信息", currentUser.getUserId());
//            Map<String, Object> result = new HashMap<>();
//            result.put("orders", new ArrayList<Order>());
//            return result;
//        }
//
//        // 查询订单列表 - 只查询自己作为商家的订单
//        List<Order> orders = orderDao.selectCustomerOrders(customer.getCustomerId());
//
//        // 为每个订单查询订单项
//        for (Order order : orders) {
//            List<OrderItem> orderItems = orderItemDao.selectOrderItemsByOrderId(order.getOrderId());
//            order.setOrderItems(orderItems);
//        }
//
//        Map<String, Object> result = new HashMap<>();
//        result.put("orders", orders);
//        return result;
//    }
    /**
     * 获取商家订单列表
     * @param request 查询参数
     * @param session 用户会话
     * @return 订单列表
     */
    @Override
    public Map<String, Object> getShopOrders(Map<String, Object> request, HttpSession session) {
        User currentUser = (User) session.getAttribute("userInfo");
        if (currentUser == null) {
            throw new RuntimeException("用户未登录");
        }

        // 查询客户（商家）信息
        Customer customer = orderDao.selectCustomerByUserId(currentUser.getUserId());
        if (customer == null) {
            log.warn("用户ID为 {} 的用户未找到对应的客户（商家）信息", currentUser.getUserId());
            Map<String, Object> result = new HashMap<>();
            result.put("orders", new ArrayList<Order>());
            return result;
        }

        // 查询订单列表 - 只查询自己作为商家的订单
        List<Order> orders = orderDao.selectCustomerOrders(customer.getCustomerId());

        // 为每个订单查询订单项，只显示属于当前商家的商品
        for (Order order : orders) {
            //List<OrderItem> orderItems = orderItemDao.selectOrderItemsByOrderId(order.getOrderId());
            List<OrderItem> orderItems = orderItemDao.selectOrderItemsByOrderIdAndCustomerId(order.getOrderId(), customer.getCustomerId());
            order.setOrderItems(orderItems);
            // 查询订单操作记录
            List<OrderAct> orderActs = orderActDao.selectOrderActsByOrderNo(order.getOrderNo());
            // 按时间倒序排列
            orderActs.sort((a, b) -> b.getCztime().compareTo(a.getCztime()));
            // 设置orderActs
            order.setOrderActs(orderActs);
            // 设置latestActno
            if (!orderActs.isEmpty()) {
                OrderAct latestAct = orderActs.get(0);
                order.setLatestActno(latestAct.getActno());
            }
        }

        Map<String, Object> result = new HashMap<>();
        result.put("orders", orders);
        return result;
    }


//    /**
//     * 发货单个商品
//     * @param itemId 商品明细ID
//     * @param session 用户会话
//     * @return 是否成功
//     */
//    @Override
//    @Transactional
//    public boolean shipItem(Long itemId, HttpSession session) {
//        User currentUser = (User) session.getAttribute("userInfo");
//
//        // 查询订单项信息
//        OrderItem orderItem = orderItemDao.selectOrderItemById(itemId);
//        if (orderItem == null) {
//            throw new RuntimeException("未找到订单项");
//        }
//
//        // 更新订单项发货状态
//        orderItem.setSortingStatus("1"); // 1表示已发货
//        orderItem.setUpdateTime(new Date());
//
//        int result = orderItemDao.updateOrderItem(orderItem);
//        if (result <= 0) {
//            return false;
//        }
//
//        // 不再创建订单操作记录
//        return true;
//    }

    /**
     * 发货单个商品
     * @param itemId 商品明细ID
     * @param session 用户会话
     * @return 是否成功
     */
    @Override
    @Transactional
    public boolean shipItem(Long itemId, HttpSession session) {
        User currentUser = (User) session.getAttribute("userInfo");

        // 查询订单项信息
        OrderItem orderItem = orderItemDao.selectOrderItemById(itemId);
        if (orderItem == null) {
            throw new RuntimeException("未找到订单项");
        }

        // 更新订单项发货状态
        orderItem.setSortingStatus("1"); // 1表示已发货
        orderItem.setUpdateTime(new Date());

        int result = orderItemDao.updateOrderItem(orderItem);
        if (result <= 0) {
            return false;
        }

        // 检查该订单下的所有商品是否都已发货
        checkAndCompleteOrder(orderItem.getOrderId(), currentUser);

        return true;
    }


    /**
     * 检查并更新订单状态（多商家支持版本）
     * @param orderId 订单ID
     * @param currentUser 当前操作用户（商家）
     */
    private void checkAndCompleteOrder(Long orderId, User currentUser) {
        // 查询订单编号
        String orderNo = orderDao.selectOrderNoById(orderId);
        if (orderNo == null || orderNo.isEmpty()) {
            return;
        }

        // 查询客户（商家）信息
        Customer customer = orderDao.selectCustomerByUserId(currentUser.getUserId());
        if (customer == null) {
            log.warn("用户ID为 {} 的用户未找到对应的客户（商家）信息", currentUser.getUserId());
            return;
        }

        // 查询订单下属于当前商家的所有订单项
        List<OrderItem> merchantOrderItems = orderItemDao.selectOrderItemsByOrderIdAndCustomerId(orderId, customer.getCustomerId());

        if (merchantOrderItems.isEmpty()) {
            return;
        }

        // 检查当前商家的商品是否都已发货
        boolean allShippedForMerchant = merchantOrderItems.stream()
                .allMatch(item -> "1".equals(item.getSortingStatus()));

        // 只有当该商家所有商品都发货时才继续处理
        if (allShippedForMerchant) {
            // 创建商家发货记录（而不是直接修改订单状态）
            OrderAct merchantShipAct = new OrderAct();
            merchantShipAct.setOrderactid(UUID.randomUUID().toString().replace("-", ""));
            merchantShipAct.setOrderNo(orderNo);
            merchantShipAct.setActno(10); // 新增状态：商家已发货（中间状态）
            merchantShipAct.setCztime(new Date());
            merchantShipAct.setCzrid(currentUser != null ? currentUser.getUserId().toString() : "system");
            merchantShipAct.setRemark("商家[" + customer.getCustomerName() + "]商品已发货");
            orderActDao.insertOrderAct(merchantShipAct);
            //等待0.01秒
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            // 检查是否所有商家都已发货完毕
            checkAllMerchantsShipped(orderId, orderNo, currentUser);
        }
    }

    /**
     * 检查所有商家是否都已发货完毕
     * @param orderId 订单ID
     * @param orderNo 订单编号
     * @param currentUser 当前用户
     */
    // 在checkAllMerchantsShipped方法中增加状态检查
    private void checkAllMerchantsShipped(Long orderId, String orderNo, User currentUser) {
        // 获取订单下所有的订单项
        List<OrderItem> allOrderItems = orderItemDao.selectOrderItemsByOrderId(orderId);

        // 检查是否所有订单项都已发货
        boolean allItemsShipped = allOrderItems.stream()
                .allMatch(item -> "1".equals(item.getSortingStatus()));

        // 如果所有商品都已发货，则更新订单整体状态
        if (allItemsShipped) {
            // 检查是否已有"已发货"状态记录
            List<OrderAct> orderActs = orderActDao.selectOrderActsByOrderNo(orderNo);
            boolean alreadyShipped = orderActs.stream()
                    .allMatch(act -> act.getActno() == 2);

            if (!alreadyShipped) {
                // 创建订单操作记录（已发货状态）
                OrderAct orderAct = new OrderAct();
                orderAct.setOrderactid(UUID.randomUUID().toString().replace("-", ""));
                orderAct.setOrderNo(orderNo);
                orderAct.setActno(2); // 2-已发货（待接收）
                orderAct.setCztime(new Date());
                orderAct.setCzrid(currentUser != null ? currentUser.getUserId().toString() : "system");
                orderAct.setRemark("订单所有商品已发货");
                orderActDao.insertOrderAct(orderAct);
            }
        }
    }




    /**
     * 获取用户订单列表
     * @param request 查询参数
     * @param session 用户会话
     * @return 订单列表
     */
    @Override
    public Map<String, Object> getUserOrders(Map<String, Object> request, HttpSession session) {
        User currentUser = (User) session.getAttribute("userInfo");
        if (currentUser == null) {
            throw new RuntimeException("用户未登录");
        }

        // 查询用户订单列表
        List<Order> orders = orderDao.selectUserOrders(currentUser.getUserId());

        // 为每个订单查询订单项和操作记录
        for (Order order : orders) {
            // 查询订单项
            List<OrderItem> orderItems = orderItemDao.selectOrderItemsByOrderId(order.getOrderId());
            order.setOrderItems(orderItems);

//            // 查询订单操作记录
//            List<OrderAct> orderActs = orderActDao.selectOrderActsByOrderNo(order.getOrderNo());
//            // 按时间倒序排列
//            orderActs.sort((a, b) -> b.getCztime().compareTo(a.getCztime()));
//
//            // 为了在前端使用，我们可以将最新的状态添加到订单对象中
//            if (!orderActs.isEmpty()) {
//                OrderAct latestAct = orderActs.get(0);
//                // 注意：Order实体类中没有status字段，我们需要通过其他方式处理
//                // 这里我们可以在Order类中添加一个临时字段来存储最新状态
//            }
            // 查询订单操作记录
            List<OrderAct> orderActs = orderActDao.selectOrderActsByOrderNo(order.getOrderNo());
// 按时间倒序排列
            orderActs.sort((a, b) -> b.getCztime().compareTo(a.getCztime()));
// ✅ 关键：设置到订单对象中
            order.setOrderActs(orderActs); // ← 添加这一行！

// 同时设置 latestActno（用于前端直接判断）
            if (!orderActs.isEmpty()) {
                OrderAct latestAct = orderActs.get(0);
                order.setLatestActno(latestAct.getActno());
            }

        }

        Map<String, Object> result = new HashMap<>();
        result.put("orders", orders);
        return result;
    }



//    /**
//     * 用户确认收货
//     * @param orderId 订单ID
//     * @param session 用户会话
//     * @return 是否成功
//     */
//    @Override
//    @Transactional
//    public boolean confirmReceipt(Long orderId, HttpSession session) {
//        User currentUser = (User) session.getAttribute("userInfo");
//
//        // 查询订单信息
//        Order order = orderDao.selectOrderById(orderId);
//        if (order == null || !order.getUserId().equals(currentUser.getUserId())) {
//            throw new RuntimeException("订单不存在或无权限操作");
//        }
//
//        // 检查是否所有商品都已发货
//        List<OrderItem> orderItems = orderItemDao.selectOrderItemsByOrderId(orderId);
//        boolean allShipped = orderItems.stream()
//                .allMatch(item -> "1".equals(item.getSortingStatus()));
//
//        if (!allShipped) {
//            throw new RuntimeException("还有商品未发货，无法确认收货");
//        }
//
//        // 更新订单完成时间
//        order.setCompleteTime(new Date());
//        order.setUpdateTime(new Date());
//        orderDao.updateOrderStatus(order);
//
//        // 创建订单操作记录（已完成状态）
//        OrderAct orderAct = new OrderAct();
//        orderAct.setOrderactid(UUID.randomUUID().toString().replace("-", ""));
//        orderAct.setOrderNo(order.getOrderNo());
//        orderAct.setActno(3); // 3-已完成
//        orderAct.setCztime(new Date());
//        orderAct.setCzrid(currentUser.getUserId().toString());
//        orderAct.setRemark("用户确认收货");
//        orderActDao.insertOrderAct(orderAct);
//
//        return true;
//    }
    /**
     * 用户确认收货（直接修改actno，不创建新记录）
     * @param orderId 订单ID
     * @param orderNo 订单编号
     * @param session 用户会话
     * @return 是否成功
     */
    @Override
    @Transactional
    public boolean confirmReceipt(Long orderId, String orderNo, HttpSession session) {
        User currentUser = (User) session.getAttribute("userInfo");

        // 查询订单信息
        Order order = orderDao.selectOrderById(orderId);
        if (order == null || !order.getUserId().equals(currentUser.getUserId())) {
            throw new RuntimeException("订单不存在或无权限操作");
        }

        // 查询最新的订单操作记录
        List<OrderAct> orderActs = orderActDao.selectOrderActsByOrderNo(orderNo);
        if (orderActs.isEmpty()) {
            throw new RuntimeException("订单状态异常");
        }

        // 按时间倒序排列，获取最新的操作记录
        orderActs.sort((a, b) -> b.getCztime().compareTo(a.getCztime()));
        OrderAct latestAct = orderActs.get(0);

        // 检查最新状态是否为"已发货"(2)
        if (latestAct.getActno() != 2) {
            throw new RuntimeException("订单状态不正确，无法确认收货");
        }

        // 检查是否所有商品都已发货
        List<OrderItem> orderItems = orderItemDao.selectOrderItemsByOrderId(orderId);
        boolean allShipped = orderItems.stream()
                .allMatch(item -> "1".equals(item.getSortingStatus()));

        if (!allShipped) {
            throw new RuntimeException("还有商品未发货，无法确认收货");
        }

        // 直接修改最新的订单操作记录，将actno从2改为3
        latestAct.setActno(3); // 3-已完成
        latestAct.setCztime(new Date());
        latestAct.setRemark("用户确认收货");

        // 更新订单操作记录
        orderActDao.updateOrderAct(latestAct);

        return true;
    }

    /**
     * 获取订单趋势数据
     * @param startDate 开始时间
     * @param endDate 结束时间
     * @return 订单趋势数据列表
     */
    @Override
    public List<Map<String, Object>> getOrderTrendData(Date startDate, Date endDate) {
        return orderDao.selectOrderTrendData(startDate, endDate);
    }
    /**
     * 获取订单状态统计
     * @return 订单状态统计列表
     */
    @Override
    public List<Map<String, Object>> getOrderStatusStats() {
        return orderDao.selectOrderStatusStats();
    }
    /**
     * 获取商品销售排名
     * @param limit 排行数量
     * @return 商品销售排名列表
     */
    @Override
    public List<Map<String, Object>> getProductSalesRanking(int limit) {
        return orderDao.selectProductSalesRanking(limit);
    }
    /**
     * 获取微信支付二维码
     * @param orderNo 订单信息
     * @return 二维码URL
     */
    @Override
    public Map getNativeByOrderNo(String orderNo) {
        try {
            // 根据订单编号查询完整订单信息
            Order order = orderDao.selectOrderByOrderNo(orderNo);
            if (order == null) {
                log.error("未找到订单编号为 {} 的订单", orderNo);
                return null;
            }

            // 检查订单中是否已存在code_url
            if (order.getCodeUrl() != null && !order.getCodeUrl().isEmpty()) {
                // 如果已存在，则直接返回已有的二维码
                Map returnMap = new HashMap<>();
                returnMap.put("code_url", order.getCodeUrl());
                return returnMap;
            }

            // 如果不存在，则调用原有的生成二维码方法
            Map resultMap = getNativeByOrder(order);

            // 将生成的二维码URL保存到订单中
            if (resultMap != null && resultMap.containsKey("code_url")) {
                order.setCodeUrl((String) resultMap.get("code_url"));
                orderDao.updateOrder(order); // 需要在OrderDao中实现此方法
            }

            return resultMap;
        } catch (Exception e) {
            log.error("根据订单编号生成支付二维码异常: ", e);
            return null;
        }
    }




}
